/**
 * 用户设备分享管理模块
 * 支持国际化的新架构
 */
const {
	userShareCollection,
	userDeviceCollection,
	dbCmd
} = require('../../common/constants')
const {
	ERROR
} = require('../../common/error')
const {
	transformMultiLangData
} = require('../../lib/transform')
const {
	getUserId
} = require('../../common/utils')

// 引入crypto模块用于生成邀请码
const crypto = require('crypto')

/**
 * 检查设备权限（辅助函数）
 * @param {string} deviceId 设备ID
 * @param {string} userId 用户ID
 * @returns {object} 设备信息
 */
async function checkDevicePermission(deviceId, userId) {
	const deviceResult = await userDeviceCollection.where({
		_id: deviceId,
		owner_id: userId
	}).get()
	
	if (deviceResult.data.length === 0) {
		throw {
			errCode: ERROR.DEVICE_ACCESS_DENIED
		}
	}
	
	return deviceResult.data[0]
}

/**
 * 根据邮箱或用户名查找用户（辅助函数）
 * @param {string} identifier 用户邮箱或用户名
 * @returns {object} 用户信息
 */
async function findUserByEmailOrUsername(identifier) {
	const db = uniCloud.database()
	const dbCmd = db.command
	
	// 判断是邮箱还是用户名
	const emailReg = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
	const isEmail = emailReg.test(identifier)
	
	// 构建查询条件：如果是邮箱格式就查邮箱，否则查用户名
	const whereCondition = isEmail 
		? { email: identifier }
		: { username: identifier }
	
	console.log('[findUserByEmailOrUsername] 查询条件:', whereCondition, '输入:', identifier)
	
	const userResult = await db.collection('uni-id-users').where(whereCondition).get()
	
	console.log('[findUserByEmailOrUsername] 查询结果:', { count: userResult.data.length })
	
	if (userResult.data.length === 0) {
		throw {
			errCode: ERROR.USER_NOT_FOUND
		}
	}
	
	return userResult.data[0]
}

// 保留旧函数名作为别名，避免其他地方调用出错
const findUserByEmail = findUserByEmailOrUsername


/**
 * 检查是否已存在分享（辅助函数）
 * @param {string} deviceId 设备ID
 * @param {string} sharedUserId 被分享用户ID
 */
async function checkExistingShare(deviceId, sharedUserId) {
	const existShareResult = await userShareCollection.where({
		device_id: deviceId,
		shared_user_id: sharedUserId,
		status: dbCmd.in([0, 1]) // 0-待接受, 1-已接受
	}).get()
	
	if (existShareResult.data.length > 0) {
		throw {
			errCode: ERROR.SHARE_ALREADY_EXISTS
		}
	}
}

/**
 * 生成邀请码（辅助函数）
 * @param {string} deviceId 设备ID
 * @param {string} sharedUserId 被分享用户ID
 * @returns {string} 邀请码
 */
function generateInviteCode(deviceId, sharedUserId) {
	const hash = crypto.createHash('md5')
	hash.update(`${deviceId}-${sharedUserId}-${Date.now()}`)
	return hash.digest('hex').substring(0, 8).toUpperCase()
}

/**
 * 发送分享邀请消息（辅助函数）
 * @param {string} sharedUserId 被分享用户ID
 * @param {object} device 设备信息
 * @param {string} shareId 分享记录ID
 * @param {string} inviteCode 邀请码
 * @param {object} [shareTitle] 分享标题（多语言）
 * @param {object} [shareMessage] 分享消息（多语言）
 */
async function sendShareInviteMessage(sharedUserId, device, shareId, inviteCode, shareTitle, shareMessage) {
	try {
		// 直接操作数据库写入消息
		const db = uniCloud.database()
		const messageCollection = db.collection('sh_user_message')
		
		// 构建消息标题
		const messageTitle = shareTitle || {
			'zh-Hans': '设备分享邀请',
			'en': 'Device Share Invitation',
			'ja': 'デバイス共有の招待',
			'ko': '장치 공유 초대',
			'es': 'Invitación para Compartir Dispositivo',
			'fr': 'Invitation de Partage d\'Appareil'
		}
		
		// 构建消息内容
		const messageContent = shareMessage || {
			'zh-Hans': `您收到了一个设备分享邀请，设备名称：${device.device_name || '未知设备'}。邀请码：${inviteCode}`,
			'en': `You have received a device sharing invitation for device: ${device.device_name || 'Unknown Device'}. Invitation code: ${inviteCode}`,
			'ja': `デバイス共有の招待を受け取りました。デバイス名：${device.device_name || '不明なデバイス'}。招待コード：${inviteCode}`,
			'ko': `장치 공유 초대를 받았습니다. 장치 이름: ${device.device_name || '알 수 없는 장치'}. 초대 코드: ${inviteCode}`,
			'es': `Ha recibido una invitación para compartir el dispositivo: ${device.device_name || 'Dispositivo Desconocido'}. Código de invitación: ${inviteCode}`,
			'fr': `Vous avez reçu une invitation de partage d'appareil pour l'appareil : ${device.device_name || 'Appareil Inconnu'}. Code d'invitation : ${inviteCode}`
		}
		
		// 构建附加数据
		const messageData = {
			type: 'share_invite',
			device_id: device._id,
			device_name: device.device_name,
			share_id: shareId,
			invite_code: inviteCode,
			owner_id: device.owner_id
		}
		
		// 创建消息文档
		const messageDoc = {
			user_id: sharedUserId,
			type: 'device_share', // 使用 device_share 类型，与前端匹配
			title: messageTitle,
			content: messageContent,
			data: messageData,
			is_read: false,
			priority: 2, // 中等优先级
			create_time: new Date()
		}
		
		// 插入消息到数据库
		await messageCollection.add(messageDoc)
		
		console.log('分享邀请消息发送成功:', { sharedUserId, deviceId: device._id, shareId, inviteCode })
	} catch (error) {
		console.error('发送分享邀请消息失败:', error)
		// 不抛出错误，避免影响分享创建流程
	}
}

/**
 * 为分享列表添加用户信息（辅助函数）
 * @param {Array} shareList 分享列表
 * @returns {Array} 增强后的分享列表
 */
async function enrichShareListWithUserInfo(shareList) {
	// 这里可以根据需要添加用户信息
	// 具体实现根据用户表结构来定
	return shareList
}

/**
 * 为邀请列表添加设备信息（辅助函数）
 * @param {Array} inviteList 邀请列表
 * @returns {Array} 增强后的邀请列表
 */
async function enrichInviteListWithDeviceInfo(inviteList) {
	// 这里可以根据需要添加设备和拥有者信息
	// 具体实现根据设备表和用户表结构来定
	return inviteList
}

/**
 * 为共享设备列表添加权限信息（辅助函数）
 * @param {Array} deviceList 设备列表
 * @param {string} userId 用户ID
 * @returns {Array} 增强后的设备列表
 */
async function enrichSharedDevicesWithPermissions(deviceList, userId) {
	// 获取用户对每个设备的分享权限
	const deviceIds = deviceList.map(device => device.device_id)
	const shareResult = await userShareCollection.where({
		device_id: dbCmd.in(deviceIds),
		shared_user_id: userId,
		status: 1 // 已接受
	}).get()
	
	// 将权限信息添加到设备列表中
	return deviceList.map(device => {
		const share = shareResult.data.find(s => s.device_id === device.device_id)
		return {
			...device,
			share_permissions: share ? share.permissions : [],
			share_id: share ? share._id : null
		}
	})
}

/**
 * 验证分享邀请（辅助函数）
 * @param {string} shareId 分享ID
 * @param {string} userId 用户ID
 * @param {string} inviteCode 邀请码
 * @returns {object} 分享信息
 */
async function validateShareInvite(shareId, userId, inviteCode) {
	console.log('validateShareInvite 参数:', { shareId, userId, inviteCode })
	
	const shareResult = await userShareCollection.where({
		_id: shareId,
		shared_user_id: userId,
		invite_code: inviteCode
	}).get()
	
	console.log('查询分享记录结果:', { count: shareResult.data.length, data: shareResult.data })
	
	if (shareResult.data.length === 0) {
		// 尝试只用 shareId 查询，看看记录是否存在
		const debugResult = await userShareCollection.where({
			_id: shareId
		}).get()
		console.log('仅用 shareId 查询结果:', debugResult.data)
		
		throw {
			errCode: ERROR.SHARE_INVALID_CODE
		}
	}
	
	const share = shareResult.data[0]
	
	// 检查分享状态
	if (share.status !== 0) {
		console.log('分享状态不是待处理:', { currentStatus: share.status, expected: 0 })
		throw {
			errCode: ERROR.SHARE_ALREADY_PROCESSED
		}
	}
	
	// 检查过期时间
	if (new Date() > new Date(share.expire_time)) {
		// 自动设置为过期状态
		await userShareCollection.doc(shareId).update({
			status: 4,
			update_time: new Date()
		})
		
		throw {
			errCode: ERROR.SHARE_EXPIRED
		}
	}
	
	return share
}

/**
 * 将用户添加到设备分享列表（辅助函数）
 * @param {string} deviceId 设备ID
 * @param {string} userId 用户ID
 */
async function addUserToDeviceShareList(deviceId, userId) {
	const deviceResult = await userDeviceCollection.doc(deviceId).get()
	if (deviceResult.data.length > 0) {
		const device = deviceResult.data[0]
		const sharedUsers = device.shared_users || []
		if (!sharedUsers.includes(userId)) {
			sharedUsers.push(userId)
			await userDeviceCollection.doc(deviceId).update({
				shared_users: sharedUsers,
				update_time: new Date()
			})
		}
	}
}

/**
 * 从设备分享列表中移除用户（辅助函数）
 * @param {string} deviceId 设备ID
 * @param {string} userId 用户ID
 */
async function removeUserFromDeviceShareList(deviceId, userId) {
	const deviceResult = await userDeviceCollection.doc(deviceId).get()
	if (deviceResult.data.length > 0) {
		const device = deviceResult.data[0]
		const sharedUsers = (device.shared_users || []).filter(id => id !== userId)
		await userDeviceCollection.doc(deviceId).update({
			shared_users: sharedUsers,
			update_time: new Date()
		})
	}
}

module.exports = {
	/**
	 * 创建设备分享
	 * @param {object} params 分享参数
	 * @param {string} params.deviceId 设备ID
	 * @param {string} params.sharedUserEmail 被分享用户邮箱
	 * @param {Array} [params.permissions=['control', 'view']] 权限列表
	 * @param {number} [params.expireDays=30] 过期天数
	 * @param {object} [params.title] 分享标题（多语言）
	 * @param {object} [params.shareMessage] 分享消息（多语言）
	 * @param {object} [params.shareNote] 分享备注（多语言）
	 * @returns {object} 分享结果
	 */
	async createShare(params) {
		const { 
			deviceId, 
			sharedUserEmail, 
			permissions = ['control', 'view'], 
			expireDays = 30,
			title,
			shareMessage,
			shareNote
		} = params
		
		if (!deviceId || !sharedUserEmail) {
			throw {
				errCode: ERROR.PARAM_REQUIRED,
				errMsgValue: { param: !deviceId ? 'deviceId' : 'sharedUserEmail' }
			}
		}
		
		try {
			const userId = await getUserId(this)
			
			// 检查设备权限
			const device = await checkDevicePermission(deviceId, userId)
			
			// 查找被分享用户
			const sharedUser = await findUserByEmail(sharedUserEmail)
			
			// 检查是否已分享给该用户
			await checkExistingShare(deviceId, sharedUser._id)
			
			// 生成邀请码
			const inviteCode = generateInviteCode(deviceId, sharedUser._id)
			
			// 计算过期时间
			const expireTime = new Date()
			expireTime.setDate(expireTime.getDate() + expireDays)
			
			// 创建分享记录
		const shareDoc = {
			device_id: deviceId,
			owner_id: userId,
			shared_user_email: sharedUserEmail,
			shared_user_id: sharedUser._id,
			permissions,
			title: title || null,
			share_message: shareMessage || null,
			share_note: shareNote || null,
			invite_code: inviteCode,
			status: 0, // 0-待接受
			created_time: new Date(),
			updated_time: new Date(),
			expire_time: new Date(Date.now() + expireDays * 24 * 60 * 60 * 1000)
		}
		
		const shareResult = await userShareCollection.add(shareDoc)
			
		// 发送邀请消息给被分享用户
		await sendShareInviteMessage(sharedUser._id, device, shareResult.id, inviteCode, title, shareMessage)
		
		return {
			errCode: 0,
			errMsg: this.t ? this.t('share.invite_sent_success') : '分享邀请发送成功',
			data: {
				shareId: shareResult.id,
				inviteCode
			}
		}
		} catch (error) {
			console.error('createShare error:', error)
			if (error.errCode) {
				throw error
			}
			throw {
				errCode: ERROR.SYSTEM_ERROR,
				errMsg: this.t ? this.t('share.invite_sent_failed') : '发送分享邀请失败'
			}
		}
	},
	
	/**
	 * 接受分享邀请
	 * @param {object} params 接受参数
	 * @param {string} params.shareId 分享ID
	 * @param {string} params.inviteCode 邀请码
	 * @returns {object} 接受结果
	 */
	async acceptShare(params) {
		const { shareId, inviteCode } = params
		
		console.log('acceptShare 接收到的参数:', { shareId, inviteCode })
		
		if (!shareId || !inviteCode) {
			throw {
				errCode: ERROR.PARAM_REQUIRED,
				errMsgValue: { param: !shareId ? 'shareId' : 'inviteCode' }
			}
		}
		
		try {
			const userId = await getUserId(this)
			console.log('当前用户ID:', userId)
			
			// 验证分享邀请
			const share = await validateShareInvite(shareId, userId, inviteCode)
			console.log('验证通过，分享信息:', share)
			
			// 更新分享状态
			await userShareCollection.doc(shareId).update({
				status: 1, // 已接受
				accept_time: new Date(),
				update_time: new Date()
			})
			
			// 更新设备的共享用户列表
			await addUserToDeviceShareList(share.device_id, userId)
			
			return {
				errCode: 0,
				errMsg: this.t ? this.t('share.accept_success') : '接受分享成功'
			}
		} catch (error) {
			console.error('acceptShare error:', error)
			if (error.errCode) {
				throw error
			}
			throw {
				errCode: ERROR.SYSTEM_ERROR,
				errMsg: this.t ? this.t('share.accept_failed') : '接受分享失败'
			}
		}
	},
	
	/**
	 * 拒绝分享邀请
	 * @param {object} params 拒绝参数
	 * @param {string} params.shareId 分享ID
	 * @param {string} [params.rejectReason] 拒绝原因
	 * @returns {object} 拒绝结果
	 */
	async rejectShare(params) {
		const { shareId, rejectReason } = params
		
		if (!shareId) {
			throw {
				errCode: ERROR.PARAM_REQUIRED,
				errMsgValue: { param: 'shareId' }
			}
		}
		
		try {
			const userId = await getUserId(this)
			
			// 查找并更新分享记录
			const updateResult = await userShareCollection.where({
				_id: shareId,
				shared_user_id: userId,
				status: 0
			}).update({
				status: 2, // 已拒绝
				reject_reason: rejectReason || '',
				update_time: new Date()
			})
			
			if (updateResult.updated === 0) {
				throw {
					errCode: ERROR.SHARE_NOT_FOUND
				}
			}
			
			return {
				errCode: 0,
				errMsg: this.t ? this.t('share.reject_success') : '拒绝分享成功'
			}
		} catch (error) {
			console.error('rejectShare error:', error)
			if (error.errCode) {
				throw error
			}
			throw {
				errCode: ERROR.SYSTEM_ERROR,
				errMsg: this.t ? this.t('share.reject_failed') : '拒绝分享失败'
			}
		}
	},
	
	/**
	 * 撤销设备分享
	 * @param {object} params 撤销参数
	 * @param {string} params.deviceId 设备ID
	 * @param {string} params.sharedUserId 被分享用户ID
	 * @param {string} [params.revokeReason] 撤销原因
	 * @returns {object} 撤销结果
	 */
	async revokeShare(params) {
		const { deviceId, sharedUserId, revokeReason } = params
		
		if (!deviceId || !sharedUserId) {
			throw {
				errCode: ERROR.PARAM_REQUIRED,
				errMsgValue: { param: !deviceId ? 'deviceId' : 'sharedUserId' }
			}
		}
		
		try {
			const userId = await getUserId(this)
			
			// 检查设备权限
			const device = await checkDevicePermission(deviceId, userId)
			
			// 更新分享状态
			const updateResult = await userShareCollection.where({
				device_id: deviceId,
				owner_id: userId,
				shared_user_id: sharedUserId,
				status: 1 // 只能撤销已接受的分享
			}).update({
				status: 3, // 已撤销
				revoke_reason: revokeReason || '',
				revoke_time: new Date(),
				update_time: new Date()
			})
			
			if (updateResult.updated === 0) {
				throw {
					errCode: ERROR.SHARE_NOT_FOUND
				}
			}
			
			// 从设备的共享用户列表中移除
			await removeUserFromDeviceShareList(deviceId, sharedUserId)
			
			return {
				errCode: 0,
				errMsg: this.t ? this.t('share.revoke_success') : '撤销分享成功'
			}
		} catch (error) {
			console.error('revokeShare error:', error)
			if (error.errCode) {
				throw error
			}
			throw {
				errCode: ERROR.SYSTEM_ERROR,
				errMsg: this.t ? this.t('share.revoke_failed') : '撤销分享失败'
			}
		}
	},
	
	/**
	 * 获取设备分享列表
	 * @param {object} params 查询参数
	 * @param {string} params.deviceId 设备ID
	 * @param {number} [params.status] 状态筛选
	 * @returns {object} 分享列表
	 */
	async getDeviceShareList(params) {
		const { deviceId, status } = params
		
		if (!deviceId) {
			throw {
				errCode: ERROR.PARAM_REQUIRED,
				errMsgValue: { param: 'deviceId' }
			}
		}
		
		try {
			const userId = await getUserId(this)
			
			// 检查设备权限
			await checkDevicePermission(deviceId, userId)
			
			// 构建查询条件
			let whereCondition = {
				device_id: deviceId,
				owner_id: userId
			}
			
			if (status !== undefined) {
				whereCondition.status = status
			}
			
			// 获取分享列表
			const shareResult = await userShareCollection
				.where(whereCondition)
				.orderBy('create_time', 'desc')
				.get()
			
			// 获取当前请求的语言
			const language = this.language || 'zh-Hans'
			
			// 转换数据格式
			const transformedData = transformMultiLangData(shareResult.data, language, {
				multiLangFields: ['share_message', 'share_note'],
				keepFields: [
					'share_id', 'device_id', 'owner_id', 'shared_user_id', 'shared_user_email',
					'permissions', 'status', 'invite_code', 'expire_time', 'accept_time',
					'reject_reason', 'revoke_reason', 'revoke_time', 'create_time', 'update_time'
				],
				idMapping: { '_id': 'share_id' }
			})
			
			// 获取被分享用户信息
			const enrichedData = await enrichShareListWithUserInfo(transformedData)
			
			return {
				errCode: 0,
				errMsg: this.t ? this.t('share.list.success') : '获取成功',
				data: {
					shares: enrichedData
				}
			}
		} catch (error) {
			console.error('getDeviceShareList error:', error)
			if (error.errCode) {
				throw error
			}
			throw {
				errCode: ERROR.SYSTEM_ERROR,
				errMsg: this.t ? this.t('share.list.failed') : '获取分享列表失败'
			}
		}
	},
	
	/**
	 * 获取用户收到的分享邀请
	 * @param {object} params 查询参数
	 * @param {number} [params.status] 状态筛选
	 * @param {number} [params.page=1] 页码
	 * @param {number} [params.limit=20] 每页数量
	 * @returns {object} 邀请列表
	 */
	async getUserShareInvites(params = {}) {
		const { status, page = 1, limit = 20 } = params
		
		try {
			const userId = await getUserId(this)
			
			// 构建查询条件
			let whereCondition = {
				shared_user_id: userId
			}
			
			if (status !== undefined) {
				whereCondition.status = status
			}
			
			// 分页查询
			const skip = (page - 1) * limit
			const inviteResult = await userShareCollection
				.where(whereCondition)
				.orderBy('create_time', 'desc')
				.skip(skip)
				.limit(limit)
				.get()
			
			// 获取总数
			const countResult = await userShareCollection.where(whereCondition).count()
			
			// 获取当前请求的语言
			const language = this.language || 'zh-Hans'
			
			// 转换数据格式
			const transformedData = transformMultiLangData(inviteResult.data, language, {
				multiLangFields: ['share_message', 'share_note'],
				keepFields: [
					'share_id', 'device_id', 'owner_id', 'shared_user_id', 'permissions',
					'status', 'invite_code', 'expire_time', 'accept_time', 'reject_reason',
					'revoke_reason', 'revoke_time', 'create_time', 'update_time'
				],
				idMapping: { '_id': 'share_id' }
			})
			
			// 获取设备和拥有者信息
			const enrichedData = await enrichInviteListWithDeviceInfo(transformedData)
			
			return {
				errCode: 0,
				errMsg: this.t ? this.t('share.invites.success') : '获取邀请列表成功',
				data: {
					invites: enrichedData,
					total: countResult.total,
					page,
					limit,
					totalPages: Math.ceil(countResult.total / limit)
				}
			}
		} catch (error) {
			console.error('getUserShareInvites error:', error)
			if (error.errCode) {
				throw error
			}
			throw {
				errCode: ERROR.SYSTEM_ERROR,
				errMsg: this.t ? this.t('share.invites.failed') : '获取邀请列表失败'
			}
		}
	},
	
	/**
	 * 获取用户分享的设备列表
	 * @param {object} params 查询参数
	 * @param {number} [params.page=1] 页码
	 * @param {number} [params.limit=20] 每页数量
	 * @returns {object} 分享设备列表
	 */
	async getSharedDevices(params = {}) {
		const { page = 1, limit = 20 } = params
		
		try {
			const userId = await getUserId(this)
			
			// 分页查询用户可访问的设备（作为被分享者）
			const skip = (page - 1) * limit
			const deviceResult = await userDeviceCollection.where({
				shared_users: dbCmd.in([userId])
			}).orderBy('update_time', 'desc')
			.skip(skip)
			.limit(limit)
			.get()
			
			// 获取总数
			const countResult = await userDeviceCollection.where({
				shared_users: dbCmd.in([userId])
			}).count()
			
			// 获取当前请求的语言
			const language = this.language || 'zh-Hans'
			
			// 转换数据格式
			const transformedData = transformMultiLangData(deviceResult.data, language, {
				multiLangFields: ['device_name'],
				keepFields: [
					'device_id', 'device_type', 'owner_id', 'shared_users', 'device_status',
					'location', 'last_online_time', 'create_time', 'update_time'
				],
				idMapping: { '_id': 'device_id' }
			})
			
			// 获取用户的分享权限信息
			const enrichedData = await enrichSharedDevicesWithPermissions(transformedData, userId)
			
			return {
				errCode: 0,
				errMsg: this.t ? this.t('share.devices.success') : '获取共享设备列表成功',
				data: {
					devices: enrichedData,
					total: countResult.total,
					page,
					limit,
					totalPages: Math.ceil(countResult.total / limit)
				}
			}
		} catch (error) {
			console.error('getSharedDevices error:', error)
			if (error.errCode) {
				throw error
			}
			throw {
				errCode: ERROR.SYSTEM_ERROR,
				errMsg: this.t ? this.t('share.devices.failed') : '获取共享设备列表失败'
			}
		}
	},
	
	/**
	 * 更新分享权限
	 * @param {object} params 更新参数
	 * @param {string} params.shareId 分享ID
	 * @param {Array} params.permissions 新的权限列表
	 * @returns {object} 更新结果
	 */
	async updateSharePermissions(params) {
		const { shareId, permissions } = params
		
		if (!shareId || !permissions || !Array.isArray(permissions)) {
			throw {
				errCode: ERROR.PARAM_REQUIRED,
				errMsgValue: { param: !shareId ? 'shareId' : 'permissions' }
			}
		}
		
		try {
			const userId = await getUserId(this)
			
			// 更新分享权限（只有设备拥有者可以更新）
			const updateResult = await userShareCollection.where({
				_id: shareId,
				owner_id: userId,
				status: 1 // 只能更新已接受的分享
			}).update({
				permissions,
				update_time: new Date()
			})
			
			if (updateResult.updated === 0) {
				throw {
					errCode: ERROR.SHARE_NOT_FOUND
				}
			}
			
			return {
				errCode: 0,
				errMsg: this.t ? this.t('share.permissions_updated_success') : '权限更新成功'
			}
		} catch (error) {
			console.error('updateSharePermissions error:', error)
			if (error.errCode) {
				throw error
			}
			throw {
				errCode: ERROR.SYSTEM_ERROR,
				errMsg: this.t ? this.t('share.permissions_updated_failed') : '权限更新失败'
			}
		}
	},
	
	// ==================== 私有方法 ====================
	// 注意：_checkDevicePermission, _findUserByEmail, _checkExistingShare, _generateInviteCode, _sendShareInviteMessage
	// 这些方法已移至模块外部作为辅助函数
	
	/**
	 * 验证分享邀请
	 * @private
	 * @param {string} shareId 分享ID
	 * @param {string} userId 用户ID
	 * @param {string} inviteCode 邀请码
	 * @returns {object} 分享信息
	 */
	async _validateShareInvite(shareId, userId, inviteCode) {
		const shareResult = await userShareCollection.where({
			_id: shareId,
			shared_user_id: userId,
			invite_code: inviteCode
		}).get()
		
		if (shareResult.data.length === 0) {
			throw {
				errCode: ERROR.SHARE_INVALID_CODE
			}
		}
		
		const share = shareResult.data[0]
		
		// 检查分享状态
		if (share.status !== 0) {
			throw {
				errCode: ERROR.SHARE_ALREADY_PROCESSED
			}
		}
		
		// 检查过期时间
		if (new Date() > new Date(share.expire_time)) {
			// 自动设置为过期状态
			await userShareCollection.doc(shareId).update({
				status: 4,
				update_time: new Date()
			})
			
			throw {
				errCode: ERROR.SHARE_EXPIRED
			}
		}
		
		return share
	},
	
	/**
	 * 将用户添加到设备分享列表
	 * @private
	 * @param {string} deviceId 设备ID
	 * @param {string} userId 用户ID
	 */
	async _addUserToDeviceShareList(deviceId, userId) {
		const deviceResult = await userDeviceCollection.doc(deviceId).get()
		if (deviceResult.data.length > 0) {
			const device = deviceResult.data[0]
			const sharedUsers = device.shared_users || []
			if (!sharedUsers.includes(userId)) {
				sharedUsers.push(userId)
				await userDeviceCollection.doc(deviceId).update({
					shared_users: sharedUsers,
					update_time: new Date()
				})
			}
		}
	},
	
	/**
	 * 从设备分享列表中移除用户
	 * @private
	 * @param {string} deviceId 设备ID
	 * @param {string} userId 用户ID
	 */
	async _removeUserFromDeviceShareList(deviceId, userId) {
		const deviceResult = await userDeviceCollection.doc(deviceId).get()
		if (deviceResult.data.length > 0) {
			const device = deviceResult.data[0]
			const sharedUsers = (device.shared_users || []).filter(id => id !== userId)
			await userDeviceCollection.doc(deviceId).update({
				shared_users: sharedUsers,
				update_time: new Date()
			})
		}
	},
	
	/**
	 * 发送分享接受消息
	 * @private
	 * @param {string} ownerId 设备拥有者ID
	 * @param {string} deviceId 设备ID
	 * @param {string} sharedUserId 被分享用户ID
	 */
	async _sendShareAcceptMessage(ownerId, deviceId, sharedUserId) {
		try {
			// 引用消息模块
			const messageModule = require('../sh_user_message')
			
			// 获取设备信息
			const deviceResult = await userDeviceCollection.doc(deviceId).get()
			const device = deviceResult.data[0] || {}
			
			// 获取用户信息（这里需要根据实际用户表查询）
			// 暂时使用用户ID作为显示名称
			const userName = sharedUserId // 实际应该查询用户真实姓名
			
			// 构建消息标题
			const messageTitle = {
				'zh-Hans': '分享邀请已接受',
				'en': 'Share Invitation Accepted',
				'ja': '共有招待が承認されました',
				'ko': '공유 초대가 수락되었습니다',
				'es': 'Invitación de Compartir Aceptada',
				'fr': 'Invitation de Partage Acceptée'
			}
			
			// 构建消息内容
			const messageContent = {
				'zh-Hans': `用户 ${userName} 已接受您的设备分享邀请，设备：${device.device_name || '未知设备'}`,
				'en': `User ${userName} has accepted your device sharing invitation for device: ${device.device_name || 'Unknown Device'}`,
				'ja': `ユーザー ${userName} があなたのデバイス共有招待を承認しました。デバイス：${device.device_name || '不明なデバイス'}`,
				'ko': `사용자 ${userName}가 장치 공유 초대를 수락했습니다. 장치: ${device.device_name || '알 수 없는 장치'}`,
				'es': `El usuario ${userName} ha aceptado su invitación para compartir el dispositivo: ${device.device_name || 'Dispositivo Desconocido'}`,
				'fr': `L'utilisateur ${userName} a accepté votre invitation de partage pour l'appareil : ${device.device_name || 'Appareil Inconnu'}`
			}
			
			// 构建附加数据
			const messageData = {
				type: 'share_accepted',
				device_id: deviceId,
				device_name: device.device_name,
				shared_user_id: sharedUserId,
				action: 'accept'
			}
			
			// 调用消息模块发送消息
			await messageModule.sendSystemMessage.call(this, {
				userId: ownerId,
				type: 'share_notification',
				title: messageTitle,
				content: messageContent,
				data: messageData,
				priority: 1 // 普通优先级
			})
			
			console.log('分享接受消息发送成功:', { ownerId, deviceId, sharedUserId })
		} catch (error) {
			console.error('发送分享接受消息失败:', error)
		}
	},
	
	/**
	 * 发送分享拒绝消息
	 * @private
	 * @param {string} shareId 分享ID
	 * @param {string} rejectReason 拒绝原因
	 */
	async _sendShareRejectMessage(shareId, rejectReason) {
		try {
			// 引用消息模块
			const messageModule = require('../sh_user_message')
			
			// 获取分享信息
			const shareResult = await userShareCollection.doc(shareId).get()
			if (shareResult.data.length === 0) return
			
			const share = shareResult.data[0]
			
			// 获取设备信息
			const deviceResult = await userDeviceCollection.doc(share.device_id).get()
			const device = deviceResult.data[0] || {}
			
			// 构建消息标题
			const messageTitle = {
				'zh-Hans': '分享邀请被拒绝',
				'en': 'Share Invitation Rejected',
				'ja': '共有招待が拒否されました',
				'ko': '공유 초대가 거부되었습니다',
				'es': 'Invitación de Compartir Rechazada',
				'fr': 'Invitation de Partage Rejetée'
			}
			
			// 构建消息内容
			let contentText = {
				'zh-Hans': `您的设备分享邀请被拒绝，设备：${device.device_name || '未知设备'}`,
				'en': `Your device sharing invitation was rejected for device: ${device.device_name || 'Unknown Device'}`,
				'ja': `デバイス共有招待が拒否されました。デバイス：${device.device_name || '不明なデバイス'}`,
				'ko': `장치 공유 초대가 거부되었습니다. 장치: ${device.device_name || '알 수 없는 장치'}`,
				'es': `Su invitación para compartir el dispositivo fue rechazada para el dispositivo: ${device.device_name || 'Dispositivo Desconocido'}`,
				'fr': `Votre invitation de partage d'appareil a été rejetée pour l'appareil : ${device.device_name || 'Appareil Inconnu'}`
			}
			
			// 如果有拒绝原因，添加到消息中
			if (rejectReason) {
				contentText = {
					'zh-Hans': contentText['zh-Hans'] + `。拒绝原因：${rejectReason}`,
					'en': contentText['en'] + `. Reason: ${rejectReason}`,
					'ja': contentText['ja'] + `。拒否理由：${rejectReason}`,
					'ko': contentText['ko'] + `. 이유: ${rejectReason}`,
					'es': contentText['es'] + `. Razón: ${rejectReason}`,
					'fr': contentText['fr'] + `. Raison : ${rejectReason}`
				}
			}
			
			// 构建附加数据
			const messageData = {
				type: 'share_rejected',
				device_id: share.device_id,
				device_name: device.device_name,
				shared_user_email: share.shared_user_email,
				reject_reason: rejectReason || '',
				action: 'reject'
			}
			
			// 调用消息模块发送消息给设备拥有者
			await messageModule.sendSystemMessage.call(this, {
				userId: share.owner_id,
				type: 'share_notification',
				title: messageTitle,
				content: contentText,
				data: messageData,
				priority: 1 // 普通优先级
			})
			
			console.log('分享拒绝消息发送成功:', { shareId, rejectReason })
		} catch (error) {
			console.error('发送分享拒绝消息失败:', error)
		}
	},
	
	/**
	 * 发送分享撤销消息
	 * @private
	 * @param {string} sharedUserId 被分享用户ID
	 * @param {object} device 设备信息
	 * @param {string} revokeReason 撤销原因
	 */
	async _sendShareRevokeMessage(sharedUserId, device, revokeReason) {
		try {
			// 引用消息模块
			const messageModule = require('../sh_user_message')
			
			// 构建消息标题
			const messageTitle = {
				'zh-Hans': '设备分享已撤销',
				'en': 'Device Share Revoked',
				'ja': 'デバイス共有が取り消されました',
				'ko': '장치 공유가 취소되었습니다',
				'es': 'Compartir Dispositivo Revocado',
				'fr': 'Partage d\'Appareil Révoqué'
			}
			
			// 构建消息内容
			let contentText = {
				'zh-Hans': `您对设备"${device.device_name || '未知设备'}"的分享权限已被撤销`,
				'en': `Your sharing access to device "${device.device_name || 'Unknown Device'}" has been revoked`,
				'ja': `デバイス「${device.device_name || '不明なデバイス'}」への共有アクセスが取り消されました`,
				'ko': `"${device.device_name || '알 수 없는 장치'}" 장치에 대한 공유 액세스가 취소되었습니다`,
				'es': `Su acceso compartido al dispositivo "${device.device_name || 'Dispositivo Desconocido'}" ha sido revocado`,
				'fr': `Votre accès partagé à l'appareil "${device.device_name || 'Appareil Inconnu'}" a été révoqué`
			}
			
			// 如果有撤销原因，添加到消息中
			if (revokeReason) {
				contentText = {
					'zh-Hans': contentText['zh-Hans'] + `。撤销原因：${revokeReason}`,
					'en': contentText['en'] + `. Reason: ${revokeReason}`,
					'ja': contentText['ja'] + `。取り消し理由：${revokeReason}`,
					'ko': contentText['ko'] + `. 이유: ${revokeReason}`,
					'es': contentText['es'] + `. Razón: ${revokeReason}`,
					'fr': contentText['fr'] + `. Raison : ${revokeReason}`
				}
			}
			
			// 构建附加数据
			const messageData = {
				type: 'share_revoked',
				device_id: device._id,
				device_name: device.device_name,
				owner_id: device.owner_id,
				revoke_reason: revokeReason || '',
				action: 'revoke'
			}
			
			// 调用消息模块发送消息
			await messageModule.sendSystemMessage.call(this, {
				userId: sharedUserId,
				type: 'share_notification',
				title: messageTitle,
				content: contentText,
				data: messageData,
				priority: 2 // 中等优先级，撤销分享是重要通知
			})
			
			console.log('分享撤销消息发送成功:', { sharedUserId, deviceId: device._id, revokeReason })
		} catch (error) {
			console.error('发送分享撤销消息失败:', error)
		}
	}
	
	// 注意：_enrichShareListWithUserInfo, _enrichInviteListWithDeviceInfo, 
	// _enrichSharedDevicesWithPermissions 这些方法已移至模块外部作为辅助函数
}

